// Bytes.cs - Bytes class implementation
//
// Author: Stephan Sundermann <stephansundermann@gmail.com>
//
// Copyright (c) 2014 Stephan Sundermann
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of version 2 of the Lesser GNU General
// Public License as published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this program; if not, write to the
// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
// Boston, MA 02111-1307, USA.

namespace GLib {

	using System;
	using System.Collections;
	using System.Collections.Generic;
	using System.Runtime.InteropServices;

	public partial class Bytes : GLib.Opaque, IComparable<Bytes>, IEquatable<Bytes> {
		[DllImport(Global.GLibNativeDll, CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr g_bytes_get_type();

		public static GLib.GType GType {
			get {
				IntPtr raw_ret = g_bytes_get_type();
				GLib.GType ret = new GLib.GType(raw_ret);
				return ret;
			}
		}

		public Bytes(IntPtr raw) : base(raw) { }

		[DllImport(Global.GLibNativeDll, CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr g_bytes_new(byte[] data, UIntPtr size);

		public Bytes(byte[] data) {
			Raw = g_bytes_new(data, new UIntPtr((ulong)data.Length));
		}

		[DllImport(Global.GLibNativeDll, CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr g_bytes_new_from_bytes(IntPtr raw, UIntPtr offset, UIntPtr length);

		public Bytes(Bytes bytes, ulong offset, ulong length) {
			Raw = g_bytes_new_from_bytes(bytes.Handle, new UIntPtr(offset), new UIntPtr(length));
		}

		[DllImport(Global.GLibNativeDll, CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr g_bytes_new_take(byte[] data, UIntPtr size);

		public static Bytes NewTake(byte[] data) {
			return new Bytes(g_bytes_new_take(data, new UIntPtr((ulong)data.Length)));
		}

		[DllImport(Global.GLibNativeDll, CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr g_bytes_new_static(byte[] data, UIntPtr size);

		public static Bytes NewStatic(byte[] data) {
			return new Bytes(g_bytes_new_static(data, new UIntPtr((ulong)data.Length)));
		}

		[DllImport(Global.GLibNativeDll, CallingConvention = CallingConvention.Cdecl)]
		static extern int g_bytes_compare(IntPtr raw, IntPtr bytes);

		public int CompareTo(Bytes bytes) {
			return g_bytes_compare(Handle, bytes.Handle);
		}

		[DllImport(Global.GLibNativeDll, CallingConvention = CallingConvention.Cdecl)]
		static extern bool g_bytes_equal(IntPtr raw, IntPtr bytes2);

		public bool Equals(Bytes other) {
			return g_bytes_equal(Handle, other.Handle);
		}

		[DllImport(Global.GLibNativeDll, CallingConvention = CallingConvention.Cdecl)]
		static extern UIntPtr g_bytes_get_size(IntPtr raw);

		public ulong Size {
			get {
				return (ulong)g_bytes_get_size(Handle);
			}
		}

		[DllImport(Global.GLibNativeDll, CallingConvention = CallingConvention.Cdecl)]
		static extern uint g_bytes_hash(IntPtr raw);

		public uint GetHash() {
			return g_bytes_hash(Handle);
		}

		[DllImport(Global.GLibNativeDll, CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr g_bytes_get_data(IntPtr raw, out UIntPtr size);

		public byte[] Data {
			get {
				UIntPtr size;
				IntPtr ptr = g_bytes_get_data(Handle, out size);

				if (ptr == IntPtr.Zero)
					return null;

				int sz = (int)size;
				byte[] bytes = new byte[sz];
				Marshal.Copy(ptr, bytes, 0, sz);

				return bytes;
			}
		}

		[DllImport(Global.GLibNativeDll, CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr g_bytes_ref(IntPtr raw);

		protected override void Ref(IntPtr raw) {
			if (!Owned) {
				g_bytes_ref(raw);
				Owned = true;
			}
		}

		[DllImport(Global.GLibNativeDll, CallingConvention = CallingConvention.Cdecl)]
		static extern void g_bytes_unref(IntPtr raw);

		protected override void Unref(IntPtr raw) {
			if (Owned) {
				g_bytes_unref(raw);
				Owned = false;
			}
		}

		class FinalizerInfo {
			IntPtr handle;

			public FinalizerInfo(IntPtr handle) {
				this.handle = handle;
			}

			public bool Handler() {
				g_bytes_unref(handle);
				return false;
			}
		}

		~Bytes() {
			if (!Owned)
				return;
			FinalizerInfo info = new FinalizerInfo(Handle);
			GLib.Timeout.Add(50, new GLib.TimeoutHandler(info.Handler));
		}
	}
}